// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.shein.order;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.SheinOrder;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(SheinOrder.class)
@Setter
@Getter
public class SheinOrderSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "SheinOrder".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 订单号(模糊搜索)
   */
  private String orderNo;

  /**
   * 订单号 比较(eq)
   */
  private String orderNoEq;
  /**
   * 订单号 比较(neq)
   */
  private String orderNoNeq;
  /**
   * 订单号 比较(gt)
   */
  private String orderNoGt;
  /**
   * 订单号 比较(gte)
   */
  private String orderNoGte;
  /**
   * 订单号 比较(lt)
   */
  private String orderNoLt;
  /**
   * 订单号 比较(lte)
   */
  private String orderNoLte;
  /**
   * 订单号 比较(contains)
   */
  private String orderNoContains;
  /**
   * 订单号 比较(notcontains)
   */
  private String orderNoNotcontains;
  /**
   * 订单号 比较(startswith)
   */
  private String orderNoStartswith;
  /**
   * 订单号 比较(endswith)
   */
  private String orderNoEndswith;
  /**
   * 订单号 比较(isnull)
   */
  private Boolean orderNoIsnull;
  /**
   * 订单号 比较(isnotnull)
   */
  private Boolean orderNoIsnotnull;

  /**
   * 订单号(精确搜索)
   */
  private List<String> orderNoInList;

  /**
   * 订单类型
   */
  private String orderType;

  /**
   * 订单类型 比较(eq)
   */
  private String orderTypeEq;
  /**
   * 订单类型 比较(neq)
   */
  private String orderTypeNeq;
  /**
   * 订单类型 比较(gt)
   */
  private String orderTypeGt;
  /**
   * 订单类型 比较(gte)
   */
  private String orderTypeGte;
  /**
   * 订单类型 比较(lt)
   */
  private String orderTypeLt;
  /**
   * 订单类型 比较(lte)
   */
  private String orderTypeLte;
  /**
   * 订单类型 比较(contains)
   */
  private String orderTypeContains;
  /**
   * 订单类型 比较(notcontains)
   */
  private String orderTypeNotcontains;
  /**
   * 订单类型 比较(startswith)
   */
  private String orderTypeStartswith;
  /**
   * 订单类型 比较(endswith)
   */
  private String orderTypeEndswith;
  /**
   * 订单类型 比较(isnull)
   */
  private Boolean orderTypeIsnull;
  /**
   * 订单类型 比较(isnotnull)
   */
  private Boolean orderTypeIsnotnull;

  /**
   * 订单类型(精确搜索)
   */
  private List<String> orderTypeInList;

  /**
   * 物流渠道
   */
  private String performanceType;

  /**
   * 物流渠道 比较(eq)
   */
  private String performanceTypeEq;
  /**
   * 物流渠道 比较(neq)
   */
  private String performanceTypeNeq;
  /**
   * 物流渠道 比较(gt)
   */
  private String performanceTypeGt;
  /**
   * 物流渠道 比较(gte)
   */
  private String performanceTypeGte;
  /**
   * 物流渠道 比较(lt)
   */
  private String performanceTypeLt;
  /**
   * 物流渠道 比较(lte)
   */
  private String performanceTypeLte;
  /**
   * 物流渠道 比较(contains)
   */
  private String performanceTypeContains;
  /**
   * 物流渠道 比较(notcontains)
   */
  private String performanceTypeNotcontains;
  /**
   * 物流渠道 比较(startswith)
   */
  private String performanceTypeStartswith;
  /**
   * 物流渠道 比较(endswith)
   */
  private String performanceTypeEndswith;
  /**
   * 物流渠道 比较(isnull)
   */
  private Boolean performanceTypeIsnull;
  /**
   * 物流渠道 比较(isnotnull)
   */
  private Boolean performanceTypeIsnotnull;

  /**
   * 物流渠道(精确搜索)
   */
  private List<String> performanceTypeInList;

  /**
   * 订单状态(模糊搜索)
   */
  private String orderStatus;

  /**
   * 订单状态 比较(eq)
   */
  private String orderStatusEq;
  /**
   * 订单状态 比较(neq)
   */
  private String orderStatusNeq;
  /**
   * 订单状态 比较(gt)
   */
  private String orderStatusGt;
  /**
   * 订单状态 比较(gte)
   */
  private String orderStatusGte;
  /**
   * 订单状态 比较(lt)
   */
  private String orderStatusLt;
  /**
   * 订单状态 比较(lte)
   */
  private String orderStatusLte;
  /**
   * 订单状态 比较(contains)
   */
  private String orderStatusContains;
  /**
   * 订单状态 比较(notcontains)
   */
  private String orderStatusNotcontains;
  /**
   * 订单状态 比较(startswith)
   */
  private String orderStatusStartswith;
  /**
   * 订单状态 比较(endswith)
   */
  private String orderStatusEndswith;
  /**
   * 订单状态 比较(isnull)
   */
  private Boolean orderStatusIsnull;
  /**
   * 订单状态 比较(isnotnull)
   */
  private Boolean orderStatusIsnotnull;

  /**
   * 订单状态(精确搜索)
   */
  private List<String> orderStatusInList;

  /**
   * 是否货到付款
   */
  private String isCod;

  /**
   * 是否货到付款 比较(eq)
   */
  private String isCodEq;
  /**
   * 是否货到付款 比较(neq)
   */
  private String isCodNeq;
  /**
   * 是否货到付款 比较(gt)
   */
  private String isCodGt;
  /**
   * 是否货到付款 比较(gte)
   */
  private String isCodGte;
  /**
   * 是否货到付款 比较(lt)
   */
  private String isCodLt;
  /**
   * 是否货到付款 比较(lte)
   */
  private String isCodLte;
  /**
   * 是否货到付款 比较(contains)
   */
  private String isCodContains;
  /**
   * 是否货到付款 比较(notcontains)
   */
  private String isCodNotcontains;
  /**
   * 是否货到付款 比较(startswith)
   */
  private String isCodStartswith;
  /**
   * 是否货到付款 比较(endswith)
   */
  private String isCodEndswith;
  /**
   * 是否货到付款 比较(isnull)
   */
  private Boolean isCodIsnull;
  /**
   * 是否货到付款 比较(isnotnull)
   */
  private Boolean isCodIsnotnull;

  /**
   * 是否货到付款(精确搜索)
   */
  private List<String> isCodInList;

  /**
   * 订单标签
   */
  private String orderTag;

  /**
   * 订单标签 比较(eq)
   */
  private String orderTagEq;
  /**
   * 订单标签 比较(neq)
   */
  private String orderTagNeq;
  /**
   * 订单标签 比较(gt)
   */
  private String orderTagGt;
  /**
   * 订单标签 比较(gte)
   */
  private String orderTagGte;
  /**
   * 订单标签 比较(lt)
   */
  private String orderTagLt;
  /**
   * 订单标签 比较(lte)
   */
  private String orderTagLte;
  /**
   * 订单标签 比较(contains)
   */
  private String orderTagContains;
  /**
   * 订单标签 比较(notcontains)
   */
  private String orderTagNotcontains;
  /**
   * 订单标签 比较(startswith)
   */
  private String orderTagStartswith;
  /**
   * 订单标签 比较(endswith)
   */
  private String orderTagEndswith;
  /**
   * 订单标签 比较(isnull)
   */
  private Boolean orderTagIsnull;
  /**
   * 订单标签 比较(isnotnull)
   */
  private Boolean orderTagIsnotnull;

  /**
   * 订单标签(精确搜索)
   */
  private List<String> orderTagInList;

  /**
   * 发货方式
   */
  private String deliveryType;

  /**
   * 发货方式 比较(eq)
   */
  private String deliveryTypeEq;
  /**
   * 发货方式 比较(neq)
   */
  private String deliveryTypeNeq;
  /**
   * 发货方式 比较(gt)
   */
  private String deliveryTypeGt;
  /**
   * 发货方式 比较(gte)
   */
  private String deliveryTypeGte;
  /**
   * 发货方式 比较(lt)
   */
  private String deliveryTypeLt;
  /**
   * 发货方式 比较(lte)
   */
  private String deliveryTypeLte;
  /**
   * 发货方式 比较(contains)
   */
  private String deliveryTypeContains;
  /**
   * 发货方式 比较(notcontains)
   */
  private String deliveryTypeNotcontains;
  /**
   * 发货方式 比较(startswith)
   */
  private String deliveryTypeStartswith;
  /**
   * 发货方式 比较(endswith)
   */
  private String deliveryTypeEndswith;
  /**
   * 发货方式 比较(isnull)
   */
  private Boolean deliveryTypeIsnull;
  /**
   * 发货方式 比较(isnotnull)
   */
  private Boolean deliveryTypeIsnotnull;

  /**
   * 发货方式(精确搜索)
   */
  private List<String> deliveryTypeInList;

  /**
   * 订单打印状态
   */
  private String printOrderStatus;

  /**
   * 订单打印状态 比较(eq)
   */
  private String printOrderStatusEq;
  /**
   * 订单打印状态 比较(neq)
   */
  private String printOrderStatusNeq;
  /**
   * 订单打印状态 比较(gt)
   */
  private String printOrderStatusGt;
  /**
   * 订单打印状态 比较(gte)
   */
  private String printOrderStatusGte;
  /**
   * 订单打印状态 比较(lt)
   */
  private String printOrderStatusLt;
  /**
   * 订单打印状态 比较(lte)
   */
  private String printOrderStatusLte;
  /**
   * 订单打印状态 比较(contains)
   */
  private String printOrderStatusContains;
  /**
   * 订单打印状态 比较(notcontains)
   */
  private String printOrderStatusNotcontains;
  /**
   * 订单打印状态 比较(startswith)
   */
  private String printOrderStatusStartswith;
  /**
   * 订单打印状态 比较(endswith)
   */
  private String printOrderStatusEndswith;
  /**
   * 订单打印状态 比较(isnull)
   */
  private Boolean printOrderStatusIsnull;
  /**
   * 订单打印状态 比较(isnotnull)
   */
  private Boolean printOrderStatusIsnotnull;

  /**
   * 订单打印状态(精确搜索)
   */
  private List<String> printOrderStatusInList;

  /**
   * 计费状态
   */
  private String invoiceStatus;

  /**
   * 计费状态 比较(eq)
   */
  private String invoiceStatusEq;
  /**
   * 计费状态 比较(neq)
   */
  private String invoiceStatusNeq;
  /**
   * 计费状态 比较(gt)
   */
  private String invoiceStatusGt;
  /**
   * 计费状态 比较(gte)
   */
  private String invoiceStatusGte;
  /**
   * 计费状态 比较(lt)
   */
  private String invoiceStatusLt;
  /**
   * 计费状态 比较(lte)
   */
  private String invoiceStatusLte;
  /**
   * 计费状态 比较(contains)
   */
  private String invoiceStatusContains;
  /**
   * 计费状态 比较(notcontains)
   */
  private String invoiceStatusNotcontains;
  /**
   * 计费状态 比较(startswith)
   */
  private String invoiceStatusStartswith;
  /**
   * 计费状态 比较(endswith)
   */
  private String invoiceStatusEndswith;
  /**
   * 计费状态 比较(isnull)
   */
  private Boolean invoiceStatusIsnull;
  /**
   * 计费状态 比较(isnotnull)
   */
  private Boolean invoiceStatusIsnotnull;

  /**
   * 计费状态(精确搜索)
   */
  private List<String> invoiceStatusInList;

  /**
   * 销售价格
   */
  private java.math.BigDecimal settleActuallyPrice;

  /**
   * 最小销售价格
   */
  private java.math.BigDecimal settleActuallyPriceMin;

  /**
   * 最大销售价格
   */
  private java.math.BigDecimal settleActuallyPriceMax;

  /**
   * 销售价格 比较(eq)
   */
  private java.math.BigDecimal settleActuallyPriceEq;
  /**
   * 销售价格 比较(neq)
   */
  private java.math.BigDecimal settleActuallyPriceNeq;
  /**
   * 销售价格 比较(gt)
   */
  private java.math.BigDecimal settleActuallyPriceGt;
  /**
   * 销售价格 比较(gte)
   */
  private java.math.BigDecimal settleActuallyPriceGte;
  /**
   * 销售价格 比较(lt)
   */
  private java.math.BigDecimal settleActuallyPriceLt;
  /**
   * 销售价格 比较(lte)
   */
  private java.math.BigDecimal settleActuallyPriceLte;
  /**
   * 销售价格 比较(contains)
   */
  private java.math.BigDecimal settleActuallyPriceContains;
  /**
   * 销售价格 比较(notcontains)
   */
  private java.math.BigDecimal settleActuallyPriceNotcontains;
  /**
   * 销售价格 比较(startswith)
   */
  private java.math.BigDecimal settleActuallyPriceStartswith;
  /**
   * 销售价格 比较(endswith)
   */
  private java.math.BigDecimal settleActuallyPriceEndswith;
  /**
   * 销售价格 比较(isnull)
   */
  private Boolean settleActuallyPriceIsnull;
  /**
   * 销售价格 比较(isnotnull)
   */
  private Boolean settleActuallyPriceIsnotnull;

  /**
   * 订单的货币(模糊搜索)
   */
  private String orderCurrency;

  /**
   * 订单的货币 比较(eq)
   */
  private String orderCurrencyEq;
  /**
   * 订单的货币 比较(neq)
   */
  private String orderCurrencyNeq;
  /**
   * 订单的货币 比较(gt)
   */
  private String orderCurrencyGt;
  /**
   * 订单的货币 比较(gte)
   */
  private String orderCurrencyGte;
  /**
   * 订单的货币 比较(lt)
   */
  private String orderCurrencyLt;
  /**
   * 订单的货币 比较(lte)
   */
  private String orderCurrencyLte;
  /**
   * 订单的货币 比较(contains)
   */
  private String orderCurrencyContains;
  /**
   * 订单的货币 比较(notcontains)
   */
  private String orderCurrencyNotcontains;
  /**
   * 订单的货币 比较(startswith)
   */
  private String orderCurrencyStartswith;
  /**
   * 订单的货币 比较(endswith)
   */
  private String orderCurrencyEndswith;
  /**
   * 订单的货币 比较(isnull)
   */
  private Boolean orderCurrencyIsnull;
  /**
   * 订单的货币 比较(isnotnull)
   */
  private Boolean orderCurrencyIsnotnull;

  /**
   * 订单的货币(精确搜索)
   */
  private List<String> orderCurrencyInList;

  /**
   * 货物总额
   */
  private java.math.BigDecimal productTotalPrice;

  /**
   * 最小货物总额
   */
  private java.math.BigDecimal productTotalPriceMin;

  /**
   * 最大货物总额
   */
  private java.math.BigDecimal productTotalPriceMax;

  /**
   * 货物总额 比较(eq)
   */
  private java.math.BigDecimal productTotalPriceEq;
  /**
   * 货物总额 比较(neq)
   */
  private java.math.BigDecimal productTotalPriceNeq;
  /**
   * 货物总额 比较(gt)
   */
  private java.math.BigDecimal productTotalPriceGt;
  /**
   * 货物总额 比较(gte)
   */
  private java.math.BigDecimal productTotalPriceGte;
  /**
   * 货物总额 比较(lt)
   */
  private java.math.BigDecimal productTotalPriceLt;
  /**
   * 货物总额 比较(lte)
   */
  private java.math.BigDecimal productTotalPriceLte;
  /**
   * 货物总额 比较(contains)
   */
  private java.math.BigDecimal productTotalPriceContains;
  /**
   * 货物总额 比较(notcontains)
   */
  private java.math.BigDecimal productTotalPriceNotcontains;
  /**
   * 货物总额 比较(startswith)
   */
  private java.math.BigDecimal productTotalPriceStartswith;
  /**
   * 货物总额 比较(endswith)
   */
  private java.math.BigDecimal productTotalPriceEndswith;
  /**
   * 货物总额 比较(isnull)
   */
  private Boolean productTotalPriceIsnull;
  /**
   * 货物总额 比较(isnotnull)
   */
  private Boolean productTotalPriceIsnotnull;

  /**
   * 商店折扣的总额
   */
  private java.math.BigDecimal storeDiscountTotalPrice;

  /**
   * 最小商店折扣的总额
   */
  private java.math.BigDecimal storeDiscountTotalPriceMin;

  /**
   * 最大商店折扣的总额
   */
  private java.math.BigDecimal storeDiscountTotalPriceMax;

  /**
   * 商店折扣的总额 比较(eq)
   */
  private java.math.BigDecimal storeDiscountTotalPriceEq;
  /**
   * 商店折扣的总额 比较(neq)
   */
  private java.math.BigDecimal storeDiscountTotalPriceNeq;
  /**
   * 商店折扣的总额 比较(gt)
   */
  private java.math.BigDecimal storeDiscountTotalPriceGt;
  /**
   * 商店折扣的总额 比较(gte)
   */
  private java.math.BigDecimal storeDiscountTotalPriceGte;
  /**
   * 商店折扣的总额 比较(lt)
   */
  private java.math.BigDecimal storeDiscountTotalPriceLt;
  /**
   * 商店折扣的总额 比较(lte)
   */
  private java.math.BigDecimal storeDiscountTotalPriceLte;
  /**
   * 商店折扣的总额 比较(contains)
   */
  private java.math.BigDecimal storeDiscountTotalPriceContains;
  /**
   * 商店折扣的总额 比较(notcontains)
   */
  private java.math.BigDecimal storeDiscountTotalPriceNotcontains;
  /**
   * 商店折扣的总额 比较(startswith)
   */
  private java.math.BigDecimal storeDiscountTotalPriceStartswith;
  /**
   * 商店折扣的总额 比较(endswith)
   */
  private java.math.BigDecimal storeDiscountTotalPriceEndswith;
  /**
   * 商店折扣的总额 比较(isnull)
   */
  private Boolean storeDiscountTotalPriceIsnull;
  /**
   * 商店折扣的总额 比较(isnotnull)
   */
  private Boolean storeDiscountTotalPriceIsnotnull;

  /**
   * 活动折扣总额
   */
  private java.math.BigDecimal promotionDiscountTotalPrice;

  /**
   * 最小活动折扣总额
   */
  private java.math.BigDecimal promotionDiscountTotalPriceMin;

  /**
   * 最大活动折扣总额
   */
  private java.math.BigDecimal promotionDiscountTotalPriceMax;

  /**
   * 活动折扣总额 比较(eq)
   */
  private java.math.BigDecimal promotionDiscountTotalPriceEq;
  /**
   * 活动折扣总额 比较(neq)
   */
  private java.math.BigDecimal promotionDiscountTotalPriceNeq;
  /**
   * 活动折扣总额 比较(gt)
   */
  private java.math.BigDecimal promotionDiscountTotalPriceGt;
  /**
   * 活动折扣总额 比较(gte)
   */
  private java.math.BigDecimal promotionDiscountTotalPriceGte;
  /**
   * 活动折扣总额 比较(lt)
   */
  private java.math.BigDecimal promotionDiscountTotalPriceLt;
  /**
   * 活动折扣总额 比较(lte)
   */
  private java.math.BigDecimal promotionDiscountTotalPriceLte;
  /**
   * 活动折扣总额 比较(contains)
   */
  private java.math.BigDecimal promotionDiscountTotalPriceContains;
  /**
   * 活动折扣总额 比较(notcontains)
   */
  private java.math.BigDecimal promotionDiscountTotalPriceNotcontains;
  /**
   * 活动折扣总额 比较(startswith)
   */
  private java.math.BigDecimal promotionDiscountTotalPriceStartswith;
  /**
   * 活动折扣总额 比较(endswith)
   */
  private java.math.BigDecimal promotionDiscountTotalPriceEndswith;
  /**
   * 活动折扣总额 比较(isnull)
   */
  private Boolean promotionDiscountTotalPriceIsnull;
  /**
   * 活动折扣总额 比较(isnotnull)
   */
  private Boolean promotionDiscountTotalPriceIsnotnull;

  /**
   * 全部佣金
   */
  private java.math.BigDecimal totalCommission;

  /**
   * 最小全部佣金
   */
  private java.math.BigDecimal totalCommissionMin;

  /**
   * 最大全部佣金
   */
  private java.math.BigDecimal totalCommissionMax;

  /**
   * 全部佣金 比较(eq)
   */
  private java.math.BigDecimal totalCommissionEq;
  /**
   * 全部佣金 比较(neq)
   */
  private java.math.BigDecimal totalCommissionNeq;
  /**
   * 全部佣金 比较(gt)
   */
  private java.math.BigDecimal totalCommissionGt;
  /**
   * 全部佣金 比较(gte)
   */
  private java.math.BigDecimal totalCommissionGte;
  /**
   * 全部佣金 比较(lt)
   */
  private java.math.BigDecimal totalCommissionLt;
  /**
   * 全部佣金 比较(lte)
   */
  private java.math.BigDecimal totalCommissionLte;
  /**
   * 全部佣金 比较(contains)
   */
  private java.math.BigDecimal totalCommissionContains;
  /**
   * 全部佣金 比较(notcontains)
   */
  private java.math.BigDecimal totalCommissionNotcontains;
  /**
   * 全部佣金 比较(startswith)
   */
  private java.math.BigDecimal totalCommissionStartswith;
  /**
   * 全部佣金 比较(endswith)
   */
  private java.math.BigDecimal totalCommissionEndswith;
  /**
   * 全部佣金 比较(isnull)
   */
  private Boolean totalCommissionIsnull;
  /**
   * 全部佣金 比较(isnotnull)
   */
  private Boolean totalCommissionIsnotnull;

  /**
   * 总服务费
   */
  private java.math.BigDecimal totalServiceCharge;

  /**
   * 最小总服务费
   */
  private java.math.BigDecimal totalServiceChargeMin;

  /**
   * 最大总服务费
   */
  private java.math.BigDecimal totalServiceChargeMax;

  /**
   * 总服务费 比较(eq)
   */
  private java.math.BigDecimal totalServiceChargeEq;
  /**
   * 总服务费 比较(neq)
   */
  private java.math.BigDecimal totalServiceChargeNeq;
  /**
   * 总服务费 比较(gt)
   */
  private java.math.BigDecimal totalServiceChargeGt;
  /**
   * 总服务费 比较(gte)
   */
  private java.math.BigDecimal totalServiceChargeGte;
  /**
   * 总服务费 比较(lt)
   */
  private java.math.BigDecimal totalServiceChargeLt;
  /**
   * 总服务费 比较(lte)
   */
  private java.math.BigDecimal totalServiceChargeLte;
  /**
   * 总服务费 比较(contains)
   */
  private java.math.BigDecimal totalServiceChargeContains;
  /**
   * 总服务费 比较(notcontains)
   */
  private java.math.BigDecimal totalServiceChargeNotcontains;
  /**
   * 总服务费 比较(startswith)
   */
  private java.math.BigDecimal totalServiceChargeStartswith;
  /**
   * 总服务费 比较(endswith)
   */
  private java.math.BigDecimal totalServiceChargeEndswith;
  /**
   * 总服务费 比较(isnull)
   */
  private Boolean totalServiceChargeIsnull;
  /**
   * 总服务费 比较(isnotnull)
   */
  private Boolean totalServiceChargeIsnotnull;

  /**
   * 履行服务总费用
   */
  private java.math.BigDecimal totalPerformanceServiceCharge;

  /**
   * 最小履行服务总费用
   */
  private java.math.BigDecimal totalPerformanceServiceChargeMin;

  /**
   * 最大履行服务总费用
   */
  private java.math.BigDecimal totalPerformanceServiceChargeMax;

  /**
   * 履行服务总费用 比较(eq)
   */
  private java.math.BigDecimal totalPerformanceServiceChargeEq;
  /**
   * 履行服务总费用 比较(neq)
   */
  private java.math.BigDecimal totalPerformanceServiceChargeNeq;
  /**
   * 履行服务总费用 比较(gt)
   */
  private java.math.BigDecimal totalPerformanceServiceChargeGt;
  /**
   * 履行服务总费用 比较(gte)
   */
  private java.math.BigDecimal totalPerformanceServiceChargeGte;
  /**
   * 履行服务总费用 比较(lt)
   */
  private java.math.BigDecimal totalPerformanceServiceChargeLt;
  /**
   * 履行服务总费用 比较(lte)
   */
  private java.math.BigDecimal totalPerformanceServiceChargeLte;
  /**
   * 履行服务总费用 比较(contains)
   */
  private java.math.BigDecimal totalPerformanceServiceChargeContains;
  /**
   * 履行服务总费用 比较(notcontains)
   */
  private java.math.BigDecimal totalPerformanceServiceChargeNotcontains;
  /**
   * 履行服务总费用 比较(startswith)
   */
  private java.math.BigDecimal totalPerformanceServiceChargeStartswith;
  /**
   * 履行服务总费用 比较(endswith)
   */
  private java.math.BigDecimal totalPerformanceServiceChargeEndswith;
  /**
   * 履行服务总费用 比较(isnull)
   */
  private Boolean totalPerformanceServiceChargeIsnull;
  /**
   * 履行服务总费用 比较(isnotnull)
   */
  private Boolean totalPerformanceServiceChargeIsnotnull;

  /**
   * 估计总收入
   */
  private java.math.BigDecimal estimatedGrossIncome;

  /**
   * 最小估计总收入
   */
  private java.math.BigDecimal estimatedGrossIncomeMin;

  /**
   * 最大估计总收入
   */
  private java.math.BigDecimal estimatedGrossIncomeMax;

  /**
   * 估计总收入 比较(eq)
   */
  private java.math.BigDecimal estimatedGrossIncomeEq;
  /**
   * 估计总收入 比较(neq)
   */
  private java.math.BigDecimal estimatedGrossIncomeNeq;
  /**
   * 估计总收入 比较(gt)
   */
  private java.math.BigDecimal estimatedGrossIncomeGt;
  /**
   * 估计总收入 比较(gte)
   */
  private java.math.BigDecimal estimatedGrossIncomeGte;
  /**
   * 估计总收入 比较(lt)
   */
  private java.math.BigDecimal estimatedGrossIncomeLt;
  /**
   * 估计总收入 比较(lte)
   */
  private java.math.BigDecimal estimatedGrossIncomeLte;
  /**
   * 估计总收入 比较(contains)
   */
  private java.math.BigDecimal estimatedGrossIncomeContains;
  /**
   * 估计总收入 比较(notcontains)
   */
  private java.math.BigDecimal estimatedGrossIncomeNotcontains;
  /**
   * 估计总收入 比较(startswith)
   */
  private java.math.BigDecimal estimatedGrossIncomeStartswith;
  /**
   * 估计总收入 比较(endswith)
   */
  private java.math.BigDecimal estimatedGrossIncomeEndswith;
  /**
   * 估计总收入 比较(isnull)
   */
  private Boolean estimatedGrossIncomeIsnull;
  /**
   * 估计总收入 比较(isnotnull)
   */
  private Boolean estimatedGrossIncomeIsnotnull;

  /**
   * 订单销售税总额
   */
  private java.math.BigDecimal totalSaleTax;

  /**
   * 最小订单销售税总额
   */
  private java.math.BigDecimal totalSaleTaxMin;

  /**
   * 最大订单销售税总额
   */
  private java.math.BigDecimal totalSaleTaxMax;

  /**
   * 订单销售税总额 比较(eq)
   */
  private java.math.BigDecimal totalSaleTaxEq;
  /**
   * 订单销售税总额 比较(neq)
   */
  private java.math.BigDecimal totalSaleTaxNeq;
  /**
   * 订单销售税总额 比较(gt)
   */
  private java.math.BigDecimal totalSaleTaxGt;
  /**
   * 订单销售税总额 比较(gte)
   */
  private java.math.BigDecimal totalSaleTaxGte;
  /**
   * 订单销售税总额 比较(lt)
   */
  private java.math.BigDecimal totalSaleTaxLt;
  /**
   * 订单销售税总额 比较(lte)
   */
  private java.math.BigDecimal totalSaleTaxLte;
  /**
   * 订单销售税总额 比较(contains)
   */
  private java.math.BigDecimal totalSaleTaxContains;
  /**
   * 订单销售税总额 比较(notcontains)
   */
  private java.math.BigDecimal totalSaleTaxNotcontains;
  /**
   * 订单销售税总额 比较(startswith)
   */
  private java.math.BigDecimal totalSaleTaxStartswith;
  /**
   * 订单销售税总额 比较(endswith)
   */
  private java.math.BigDecimal totalSaleTaxEndswith;
  /**
   * 订单销售税总额 比较(isnull)
   */
  private Boolean totalSaleTaxIsnull;
  /**
   * 订单销售税总额 比较(isnotnull)
   */
  private Boolean totalSaleTaxIsnotnull;

  /**
   * 最早分阶时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderAllocateTimeStart;

  /**
   * 最晚分阶时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderAllocateTimeEnd;

  /**
   * 分阶时间 比较(eq)
   */
  private Date orderAllocateTimeEq;
  /**
   * 分阶时间 比较(neq)
   */
  private Date orderAllocateTimeNeq;
  /**
   * 分阶时间 比较(gt)
   */
  private Date orderAllocateTimeGt;
  /**
   * 分阶时间 比较(gte)
   */
  private Date orderAllocateTimeGte;
  /**
   * 分阶时间 比较(lt)
   */
  private Date orderAllocateTimeLt;
  /**
   * 分阶时间 比较(lte)
   */
  private Date orderAllocateTimeLte;
  /**
   * 分阶时间 比较(contains)
   */
  private Date orderAllocateTimeContains;
  /**
   * 分阶时间 比较(notcontains)
   */
  private Date orderAllocateTimeNotcontains;
  /**
   * 分阶时间 比较(startswith)
   */
  private Date orderAllocateTimeStartswith;
  /**
   * 分阶时间 比较(endswith)
   */
  private Date orderAllocateTimeEndswith;
  /**
   * 分阶时间 比较(isnull)
   */
  private Boolean orderAllocateTimeIsnull;
  /**
   * 分阶时间 比较(isnotnull)
   */
  private Boolean orderAllocateTimeIsnotnull;

  /**
   * 最早请求交付时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date requestDeliveryTimeStart;

  /**
   * 最晚请求交付时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date requestDeliveryTimeEnd;

  /**
   * 请求交付时间 比较(eq)
   */
  private Date requestDeliveryTimeEq;
  /**
   * 请求交付时间 比较(neq)
   */
  private Date requestDeliveryTimeNeq;
  /**
   * 请求交付时间 比较(gt)
   */
  private Date requestDeliveryTimeGt;
  /**
   * 请求交付时间 比较(gte)
   */
  private Date requestDeliveryTimeGte;
  /**
   * 请求交付时间 比较(lt)
   */
  private Date requestDeliveryTimeLt;
  /**
   * 请求交付时间 比较(lte)
   */
  private Date requestDeliveryTimeLte;
  /**
   * 请求交付时间 比较(contains)
   */
  private Date requestDeliveryTimeContains;
  /**
   * 请求交付时间 比较(notcontains)
   */
  private Date requestDeliveryTimeNotcontains;
  /**
   * 请求交付时间 比较(startswith)
   */
  private Date requestDeliveryTimeStartswith;
  /**
   * 请求交付时间 比较(endswith)
   */
  private Date requestDeliveryTimeEndswith;
  /**
   * 请求交付时间 比较(isnull)
   */
  private Boolean requestDeliveryTimeIsnull;
  /**
   * 请求交付时间 比较(isnotnull)
   */
  private Boolean requestDeliveryTimeIsnotnull;

  /**
   * 最早打印时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date printingTimeStart;

  /**
   * 最晚打印时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date printingTimeEnd;

  /**
   * 打印时间 比较(eq)
   */
  private Date printingTimeEq;
  /**
   * 打印时间 比较(neq)
   */
  private Date printingTimeNeq;
  /**
   * 打印时间 比较(gt)
   */
  private Date printingTimeGt;
  /**
   * 打印时间 比较(gte)
   */
  private Date printingTimeGte;
  /**
   * 打印时间 比较(lt)
   */
  private Date printingTimeLt;
  /**
   * 打印时间 比较(lte)
   */
  private Date printingTimeLte;
  /**
   * 打印时间 比较(contains)
   */
  private Date printingTimeContains;
  /**
   * 打印时间 比较(notcontains)
   */
  private Date printingTimeNotcontains;
  /**
   * 打印时间 比较(startswith)
   */
  private Date printingTimeStartswith;
  /**
   * 打印时间 比较(endswith)
   */
  private Date printingTimeEndswith;
  /**
   * 打印时间 比较(isnull)
   */
  private Boolean printingTimeIsnull;
  /**
   * 打印时间 比较(isnotnull)
   */
  private Boolean printingTimeIsnotnull;

  /**
   * 最早预计交货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date scheduleDeliveryTimeStart;

  /**
   * 最晚预计交货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date scheduleDeliveryTimeEnd;

  /**
   * 预计交货时间 比较(eq)
   */
  private Date scheduleDeliveryTimeEq;
  /**
   * 预计交货时间 比较(neq)
   */
  private Date scheduleDeliveryTimeNeq;
  /**
   * 预计交货时间 比较(gt)
   */
  private Date scheduleDeliveryTimeGt;
  /**
   * 预计交货时间 比较(gte)
   */
  private Date scheduleDeliveryTimeGte;
  /**
   * 预计交货时间 比较(lt)
   */
  private Date scheduleDeliveryTimeLt;
  /**
   * 预计交货时间 比较(lte)
   */
  private Date scheduleDeliveryTimeLte;
  /**
   * 预计交货时间 比较(contains)
   */
  private Date scheduleDeliveryTimeContains;
  /**
   * 预计交货时间 比较(notcontains)
   */
  private Date scheduleDeliveryTimeNotcontains;
  /**
   * 预计交货时间 比较(startswith)
   */
  private Date scheduleDeliveryTimeStartswith;
  /**
   * 预计交货时间 比较(endswith)
   */
  private Date scheduleDeliveryTimeEndswith;
  /**
   * 预计交货时间 比较(isnull)
   */
  private Boolean scheduleDeliveryTimeIsnull;
  /**
   * 预计交货时间 比较(isnotnull)
   */
  private Boolean scheduleDeliveryTimeIsnotnull;

  /**
   * 最早领取及签收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date pickUpTimeStart;

  /**
   * 最晚领取及签收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date pickUpTimeEnd;

  /**
   * 领取及签收时间 比较(eq)
   */
  private Date pickUpTimeEq;
  /**
   * 领取及签收时间 比较(neq)
   */
  private Date pickUpTimeNeq;
  /**
   * 领取及签收时间 比较(gt)
   */
  private Date pickUpTimeGt;
  /**
   * 领取及签收时间 比较(gte)
   */
  private Date pickUpTimeGte;
  /**
   * 领取及签收时间 比较(lt)
   */
  private Date pickUpTimeLt;
  /**
   * 领取及签收时间 比较(lte)
   */
  private Date pickUpTimeLte;
  /**
   * 领取及签收时间 比较(contains)
   */
  private Date pickUpTimeContains;
  /**
   * 领取及签收时间 比较(notcontains)
   */
  private Date pickUpTimeNotcontains;
  /**
   * 领取及签收时间 比较(startswith)
   */
  private Date pickUpTimeStartswith;
  /**
   * 领取及签收时间 比较(endswith)
   */
  private Date pickUpTimeEndswith;
  /**
   * 领取及签收时间 比较(isnull)
   */
  private Boolean pickUpTimeIsnull;
  /**
   * 领取及签收时间 比较(isnotnull)
   */
  private Boolean pickUpTimeIsnotnull;

  /**
   * 最早订单接收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderReceiptTimeStart;

  /**
   * 最晚订单接收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderReceiptTimeEnd;

  /**
   * 订单接收时间 比较(eq)
   */
  private Date orderReceiptTimeEq;
  /**
   * 订单接收时间 比较(neq)
   */
  private Date orderReceiptTimeNeq;
  /**
   * 订单接收时间 比较(gt)
   */
  private Date orderReceiptTimeGt;
  /**
   * 订单接收时间 比较(gte)
   */
  private Date orderReceiptTimeGte;
  /**
   * 订单接收时间 比较(lt)
   */
  private Date orderReceiptTimeLt;
  /**
   * 订单接收时间 比较(lte)
   */
  private Date orderReceiptTimeLte;
  /**
   * 订单接收时间 比较(contains)
   */
  private Date orderReceiptTimeContains;
  /**
   * 订单接收时间 比较(notcontains)
   */
  private Date orderReceiptTimeNotcontains;
  /**
   * 订单接收时间 比较(startswith)
   */
  private Date orderReceiptTimeStartswith;
  /**
   * 订单接收时间 比较(endswith)
   */
  private Date orderReceiptTimeEndswith;
  /**
   * 订单接收时间 比较(isnull)
   */
  private Boolean orderReceiptTimeIsnull;
  /**
   * 订单接收时间 比较(isnotnull)
   */
  private Boolean orderReceiptTimeIsnotnull;

  /**
   * 最早订单退款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderReturnTimeStart;

  /**
   * 最晚订单退款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderReturnTimeEnd;

  /**
   * 订单退款时间 比较(eq)
   */
  private Date orderReturnTimeEq;
  /**
   * 订单退款时间 比较(neq)
   */
  private Date orderReturnTimeNeq;
  /**
   * 订单退款时间 比较(gt)
   */
  private Date orderReturnTimeGt;
  /**
   * 订单退款时间 比较(gte)
   */
  private Date orderReturnTimeGte;
  /**
   * 订单退款时间 比较(lt)
   */
  private Date orderReturnTimeLt;
  /**
   * 订单退款时间 比较(lte)
   */
  private Date orderReturnTimeLte;
  /**
   * 订单退款时间 比较(contains)
   */
  private Date orderReturnTimeContains;
  /**
   * 订单退款时间 比较(notcontains)
   */
  private Date orderReturnTimeNotcontains;
  /**
   * 订单退款时间 比较(startswith)
   */
  private Date orderReturnTimeStartswith;
  /**
   * 订单退款时间 比较(endswith)
   */
  private Date orderReturnTimeEndswith;
  /**
   * 订单退款时间 比较(isnull)
   */
  private Boolean orderReturnTimeIsnull;
  /**
   * 订单退款时间 比较(isnotnull)
   */
  private Boolean orderReturnTimeIsnotnull;

  /**
   * 最早订单信息更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderMsgUpdateTimeStart;

  /**
   * 最晚订单信息更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderMsgUpdateTimeEnd;

  /**
   * 订单信息更新时间 比较(eq)
   */
  private Date orderMsgUpdateTimeEq;
  /**
   * 订单信息更新时间 比较(neq)
   */
  private Date orderMsgUpdateTimeNeq;
  /**
   * 订单信息更新时间 比较(gt)
   */
  private Date orderMsgUpdateTimeGt;
  /**
   * 订单信息更新时间 比较(gte)
   */
  private Date orderMsgUpdateTimeGte;
  /**
   * 订单信息更新时间 比较(lt)
   */
  private Date orderMsgUpdateTimeLt;
  /**
   * 订单信息更新时间 比较(lte)
   */
  private Date orderMsgUpdateTimeLte;
  /**
   * 订单信息更新时间 比较(contains)
   */
  private Date orderMsgUpdateTimeContains;
  /**
   * 订单信息更新时间 比较(notcontains)
   */
  private Date orderMsgUpdateTimeNotcontains;
  /**
   * 订单信息更新时间 比较(startswith)
   */
  private Date orderMsgUpdateTimeStartswith;
  /**
   * 订单信息更新时间 比较(endswith)
   */
  private Date orderMsgUpdateTimeEndswith;
  /**
   * 订单信息更新时间 比较(isnull)
   */
  private Boolean orderMsgUpdateTimeIsnull;
  /**
   * 订单信息更新时间 比较(isnotnull)
   */
  private Boolean orderMsgUpdateTimeIsnotnull;

  /**
   * 最早下单时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderTimeStart;

  /**
   * 最晚下单时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderTimeEnd;

  /**
   * 下单时间 比较(eq)
   */
  private Date orderTimeEq;
  /**
   * 下单时间 比较(neq)
   */
  private Date orderTimeNeq;
  /**
   * 下单时间 比较(gt)
   */
  private Date orderTimeGt;
  /**
   * 下单时间 比较(gte)
   */
  private Date orderTimeGte;
  /**
   * 下单时间 比较(lt)
   */
  private Date orderTimeLt;
  /**
   * 下单时间 比较(lte)
   */
  private Date orderTimeLte;
  /**
   * 下单时间 比较(contains)
   */
  private Date orderTimeContains;
  /**
   * 下单时间 比较(notcontains)
   */
  private Date orderTimeNotcontains;
  /**
   * 下单时间 比较(startswith)
   */
  private Date orderTimeStartswith;
  /**
   * 下单时间 比较(endswith)
   */
  private Date orderTimeEndswith;
  /**
   * 下单时间 比较(isnull)
   */
  private Boolean orderTimeIsnull;
  /**
   * 下单时间 比较(isnotnull)
   */
  private Boolean orderTimeIsnotnull;

  /**
   * 最早付款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date paymentTimeStart;

  /**
   * 最晚付款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date paymentTimeEnd;

  /**
   * 付款时间 比较(eq)
   */
  private Date paymentTimeEq;
  /**
   * 付款时间 比较(neq)
   */
  private Date paymentTimeNeq;
  /**
   * 付款时间 比较(gt)
   */
  private Date paymentTimeGt;
  /**
   * 付款时间 比较(gte)
   */
  private Date paymentTimeGte;
  /**
   * 付款时间 比较(lt)
   */
  private Date paymentTimeLt;
  /**
   * 付款时间 比较(lte)
   */
  private Date paymentTimeLte;
  /**
   * 付款时间 比较(contains)
   */
  private Date paymentTimeContains;
  /**
   * 付款时间 比较(notcontains)
   */
  private Date paymentTimeNotcontains;
  /**
   * 付款时间 比较(startswith)
   */
  private Date paymentTimeStartswith;
  /**
   * 付款时间 比较(endswith)
   */
  private Date paymentTimeEndswith;
  /**
   * 付款时间 比较(isnull)
   */
  private Boolean paymentTimeIsnull;
  /**
   * 付款时间 比较(isnotnull)
   */
  private Boolean paymentTimeIsnotnull;

  /**
   * 最早卖方交货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date sellerDeliveryTimeStart;

  /**
   * 最晚卖方交货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date sellerDeliveryTimeEnd;

  /**
   * 卖方交货时间 比较(eq)
   */
  private Date sellerDeliveryTimeEq;
  /**
   * 卖方交货时间 比较(neq)
   */
  private Date sellerDeliveryTimeNeq;
  /**
   * 卖方交货时间 比较(gt)
   */
  private Date sellerDeliveryTimeGt;
  /**
   * 卖方交货时间 比较(gte)
   */
  private Date sellerDeliveryTimeGte;
  /**
   * 卖方交货时间 比较(lt)
   */
  private Date sellerDeliveryTimeLt;
  /**
   * 卖方交货时间 比较(lte)
   */
  private Date sellerDeliveryTimeLte;
  /**
   * 卖方交货时间 比较(contains)
   */
  private Date sellerDeliveryTimeContains;
  /**
   * 卖方交货时间 比较(notcontains)
   */
  private Date sellerDeliveryTimeNotcontains;
  /**
   * 卖方交货时间 比较(startswith)
   */
  private Date sellerDeliveryTimeStartswith;
  /**
   * 卖方交货时间 比较(endswith)
   */
  private Date sellerDeliveryTimeEndswith;
  /**
   * 卖方交货时间 比较(isnull)
   */
  private Boolean sellerDeliveryTimeIsnull;
  /**
   * 卖方交货时间 比较(isnotnull)
   */
  private Boolean sellerDeliveryTimeIsnotnull;

  /**
   * 最早仓库交货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date warehouseDeliveryTimeStart;

  /**
   * 最晚仓库交货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date warehouseDeliveryTimeEnd;

  /**
   * 仓库交货时间 比较(eq)
   */
  private Date warehouseDeliveryTimeEq;
  /**
   * 仓库交货时间 比较(neq)
   */
  private Date warehouseDeliveryTimeNeq;
  /**
   * 仓库交货时间 比较(gt)
   */
  private Date warehouseDeliveryTimeGt;
  /**
   * 仓库交货时间 比较(gte)
   */
  private Date warehouseDeliveryTimeGte;
  /**
   * 仓库交货时间 比较(lt)
   */
  private Date warehouseDeliveryTimeLt;
  /**
   * 仓库交货时间 比较(lte)
   */
  private Date warehouseDeliveryTimeLte;
  /**
   * 仓库交货时间 比较(contains)
   */
  private Date warehouseDeliveryTimeContains;
  /**
   * 仓库交货时间 比较(notcontains)
   */
  private Date warehouseDeliveryTimeNotcontains;
  /**
   * 仓库交货时间 比较(startswith)
   */
  private Date warehouseDeliveryTimeStartswith;
  /**
   * 仓库交货时间 比较(endswith)
   */
  private Date warehouseDeliveryTimeEndswith;
  /**
   * 仓库交货时间 比较(isnull)
   */
  private Boolean warehouseDeliveryTimeIsnull;
  /**
   * 仓库交货时间 比较(isnotnull)
   */
  private Boolean warehouseDeliveryTimeIsnotnull;

  /**
   * 最早拒绝订单时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderRejectionTimeStart;

  /**
   * 最晚拒绝订单时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderRejectionTimeEnd;

  /**
   * 拒绝订单时间 比较(eq)
   */
  private Date orderRejectionTimeEq;
  /**
   * 拒绝订单时间 比较(neq)
   */
  private Date orderRejectionTimeNeq;
  /**
   * 拒绝订单时间 比较(gt)
   */
  private Date orderRejectionTimeGt;
  /**
   * 拒绝订单时间 比较(gte)
   */
  private Date orderRejectionTimeGte;
  /**
   * 拒绝订单时间 比较(lt)
   */
  private Date orderRejectionTimeLt;
  /**
   * 拒绝订单时间 比较(lte)
   */
  private Date orderRejectionTimeLte;
  /**
   * 拒绝订单时间 比较(contains)
   */
  private Date orderRejectionTimeContains;
  /**
   * 拒绝订单时间 比较(notcontains)
   */
  private Date orderRejectionTimeNotcontains;
  /**
   * 拒绝订单时间 比较(startswith)
   */
  private Date orderRejectionTimeStartswith;
  /**
   * 拒绝订单时间 比较(endswith)
   */
  private Date orderRejectionTimeEndswith;
  /**
   * 拒绝订单时间 比较(isnull)
   */
  private Boolean orderRejectionTimeIsnull;
  /**
   * 拒绝订单时间 比较(isnotnull)
   */
  private Boolean orderRejectionTimeIsnotnull;

  /**
   * 最早订单报失时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderReportedLossTimeStart;

  /**
   * 最晚订单报失时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderReportedLossTimeEnd;

  /**
   * 订单报失时间 比较(eq)
   */
  private Date orderReportedLossTimeEq;
  /**
   * 订单报失时间 比较(neq)
   */
  private Date orderReportedLossTimeNeq;
  /**
   * 订单报失时间 比较(gt)
   */
  private Date orderReportedLossTimeGt;
  /**
   * 订单报失时间 比较(gte)
   */
  private Date orderReportedLossTimeGte;
  /**
   * 订单报失时间 比较(lt)
   */
  private Date orderReportedLossTimeLt;
  /**
   * 订单报失时间 比较(lte)
   */
  private Date orderReportedLossTimeLte;
  /**
   * 订单报失时间 比较(contains)
   */
  private Date orderReportedLossTimeContains;
  /**
   * 订单报失时间 比较(notcontains)
   */
  private Date orderReportedLossTimeNotcontains;
  /**
   * 订单报失时间 比较(startswith)
   */
  private Date orderReportedLossTimeStartswith;
  /**
   * 订单报失时间 比较(endswith)
   */
  private Date orderReportedLossTimeEndswith;
  /**
   * 订单报失时间 比较(isnull)
   */
  private Boolean orderReportedLossTimeIsnull;
  /**
   * 订单报失时间 比较(isnotnull)
   */
  private Boolean orderReportedLossTimeIsnotnull;

  /**
   * OPS订单号(模糊搜索)
   */
  private String billNo;

  /**
   * OPS订单号 比较(eq)
   */
  private String billNoEq;
  /**
   * OPS订单号 比较(neq)
   */
  private String billNoNeq;
  /**
   * OPS订单号 比较(gt)
   */
  private String billNoGt;
  /**
   * OPS订单号 比较(gte)
   */
  private String billNoGte;
  /**
   * OPS订单号 比较(lt)
   */
  private String billNoLt;
  /**
   * OPS订单号 比较(lte)
   */
  private String billNoLte;
  /**
   * OPS订单号 比较(contains)
   */
  private String billNoContains;
  /**
   * OPS订单号 比较(notcontains)
   */
  private String billNoNotcontains;
  /**
   * OPS订单号 比较(startswith)
   */
  private String billNoStartswith;
  /**
   * OPS订单号 比较(endswith)
   */
  private String billNoEndswith;
  /**
   * OPS订单号 比较(isnull)
   */
  private Boolean billNoIsnull;
  /**
   * OPS订单号 比较(isnotnull)
   */
  private Boolean billNoIsnotnull;

  /**
   * OPS订单号(精确搜索)
   */
  private List<String> billNoInList;

  /**
   * 市场区域
   */
  private String salesArea;

  /**
   * 市场区域 比较(eq)
   */
  private String salesAreaEq;
  /**
   * 市场区域 比较(neq)
   */
  private String salesAreaNeq;
  /**
   * 市场区域 比较(gt)
   */
  private String salesAreaGt;
  /**
   * 市场区域 比较(gte)
   */
  private String salesAreaGte;
  /**
   * 市场区域 比较(lt)
   */
  private String salesAreaLt;
  /**
   * 市场区域 比较(lte)
   */
  private String salesAreaLte;
  /**
   * 市场区域 比较(contains)
   */
  private String salesAreaContains;
  /**
   * 市场区域 比较(notcontains)
   */
  private String salesAreaNotcontains;
  /**
   * 市场区域 比较(startswith)
   */
  private String salesAreaStartswith;
  /**
   * 市场区域 比较(endswith)
   */
  private String salesAreaEndswith;
  /**
   * 市场区域 比较(isnull)
   */
  private Boolean salesAreaIsnull;
  /**
   * 市场区域 比较(isnotnull)
   */
  private Boolean salesAreaIsnotnull;

  /**
   * 市场区域(精确搜索)
   */
  private List<String> salesAreaInList;

  /**
   * 库存模式
   */
  private String stockMode;

  /**
   * 库存模式 比较(eq)
   */
  private String stockModeEq;
  /**
   * 库存模式 比较(neq)
   */
  private String stockModeNeq;
  /**
   * 库存模式 比较(gt)
   */
  private String stockModeGt;
  /**
   * 库存模式 比较(gte)
   */
  private String stockModeGte;
  /**
   * 库存模式 比较(lt)
   */
  private String stockModeLt;
  /**
   * 库存模式 比较(lte)
   */
  private String stockModeLte;
  /**
   * 库存模式 比较(contains)
   */
  private String stockModeContains;
  /**
   * 库存模式 比较(notcontains)
   */
  private String stockModeNotcontains;
  /**
   * 库存模式 比较(startswith)
   */
  private String stockModeStartswith;
  /**
   * 库存模式 比较(endswith)
   */
  private String stockModeEndswith;
  /**
   * 库存模式 比较(isnull)
   */
  private Boolean stockModeIsnull;
  /**
   * 库存模式 比较(isnotnull)
   */
  private Boolean stockModeIsnotnull;

  /**
   * 库存模式(精确搜索)
   */
  private List<String> stockModeInList;

  /**
   * 销售网站(模糊搜索)
   */
  private String salesSite;

  /**
   * 销售网站 比较(eq)
   */
  private String salesSiteEq;
  /**
   * 销售网站 比较(neq)
   */
  private String salesSiteNeq;
  /**
   * 销售网站 比较(gt)
   */
  private String salesSiteGt;
  /**
   * 销售网站 比较(gte)
   */
  private String salesSiteGte;
  /**
   * 销售网站 比较(lt)
   */
  private String salesSiteLt;
  /**
   * 销售网站 比较(lte)
   */
  private String salesSiteLte;
  /**
   * 销售网站 比较(contains)
   */
  private String salesSiteContains;
  /**
   * 销售网站 比较(notcontains)
   */
  private String salesSiteNotcontains;
  /**
   * 销售网站 比较(startswith)
   */
  private String salesSiteStartswith;
  /**
   * 销售网站 比较(endswith)
   */
  private String salesSiteEndswith;
  /**
   * 销售网站 比较(isnull)
   */
  private Boolean salesSiteIsnull;
  /**
   * 销售网站 比较(isnotnull)
   */
  private Boolean salesSiteIsnotnull;

  /**
   * 销售网站(精确搜索)
   */
  private List<String> salesSiteInList;

  /**
   * 店铺编码(模糊搜索)
   */
  private String storeCode;

  /**
   * 店铺编码 比较(eq)
   */
  private String storeCodeEq;
  /**
   * 店铺编码 比较(neq)
   */
  private String storeCodeNeq;
  /**
   * 店铺编码 比较(gt)
   */
  private String storeCodeGt;
  /**
   * 店铺编码 比较(gte)
   */
  private String storeCodeGte;
  /**
   * 店铺编码 比较(lt)
   */
  private String storeCodeLt;
  /**
   * 店铺编码 比较(lte)
   */
  private String storeCodeLte;
  /**
   * 店铺编码 比较(contains)
   */
  private String storeCodeContains;
  /**
   * 店铺编码 比较(notcontains)
   */
  private String storeCodeNotcontains;
  /**
   * 店铺编码 比较(startswith)
   */
  private String storeCodeStartswith;
  /**
   * 店铺编码 比较(endswith)
   */
  private String storeCodeEndswith;
  /**
   * 店铺编码 比较(isnull)
   */
  private Boolean storeCodeIsnull;
  /**
   * 店铺编码 比较(isnotnull)
   */
  private Boolean storeCodeIsnotnull;

  /**
   * 店铺编码(精确搜索)
   */
  private List<String> storeCodeInList;

  /**
   * 最早CutOff包裹的预计领取时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expectedCollectTimeStart;

  /**
   * 最晚CutOff包裹的预计领取时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expectedCollectTimeEnd;

  /**
   * CutOff包裹的预计领取时间 比较(eq)
   */
  private Date expectedCollectTimeEq;
  /**
   * CutOff包裹的预计领取时间 比较(neq)
   */
  private Date expectedCollectTimeNeq;
  /**
   * CutOff包裹的预计领取时间 比较(gt)
   */
  private Date expectedCollectTimeGt;
  /**
   * CutOff包裹的预计领取时间 比较(gte)
   */
  private Date expectedCollectTimeGte;
  /**
   * CutOff包裹的预计领取时间 比较(lt)
   */
  private Date expectedCollectTimeLt;
  /**
   * CutOff包裹的预计领取时间 比较(lte)
   */
  private Date expectedCollectTimeLte;
  /**
   * CutOff包裹的预计领取时间 比较(contains)
   */
  private Date expectedCollectTimeContains;
  /**
   * CutOff包裹的预计领取时间 比较(notcontains)
   */
  private Date expectedCollectTimeNotcontains;
  /**
   * CutOff包裹的预计领取时间 比较(startswith)
   */
  private Date expectedCollectTimeStartswith;
  /**
   * CutOff包裹的预计领取时间 比较(endswith)
   */
  private Date expectedCollectTimeEndswith;
  /**
   * CutOff包裹的预计领取时间 比较(isnull)
   */
  private Boolean expectedCollectTimeIsnull;
  /**
   * CutOff包裹的预计领取时间 比较(isnotnull)
   */
  private Boolean expectedCollectTimeIsnotnull;

  /**
   * 店铺
   */
  private Long sid;

  /**
   * 最小店铺
   */
  private Long sidMin;

  /**
   * 最大店铺
   */
  private Long sidMax;

  /**
   * 店铺 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean sidIsnotnull;

  /**
   * 姓(模糊搜索)
   */
  private String lastName;

  /**
   * 姓 比较(eq)
   */
  private String lastNameEq;
  /**
   * 姓 比较(neq)
   */
  private String lastNameNeq;
  /**
   * 姓 比较(gt)
   */
  private String lastNameGt;
  /**
   * 姓 比较(gte)
   */
  private String lastNameGte;
  /**
   * 姓 比较(lt)
   */
  private String lastNameLt;
  /**
   * 姓 比较(lte)
   */
  private String lastNameLte;
  /**
   * 姓 比较(contains)
   */
  private String lastNameContains;
  /**
   * 姓 比较(notcontains)
   */
  private String lastNameNotcontains;
  /**
   * 姓 比较(startswith)
   */
  private String lastNameStartswith;
  /**
   * 姓 比较(endswith)
   */
  private String lastNameEndswith;
  /**
   * 姓 比较(isnull)
   */
  private Boolean lastNameIsnull;
  /**
   * 姓 比较(isnotnull)
   */
  private Boolean lastNameIsnotnull;

  /**
   * 姓(精确搜索)
   */
  private List<String> lastNameInList;

  /**
   * 中间名(模糊搜索)
   */
  private String middleName;

  /**
   * 中间名 比较(eq)
   */
  private String middleNameEq;
  /**
   * 中间名 比较(neq)
   */
  private String middleNameNeq;
  /**
   * 中间名 比较(gt)
   */
  private String middleNameGt;
  /**
   * 中间名 比较(gte)
   */
  private String middleNameGte;
  /**
   * 中间名 比较(lt)
   */
  private String middleNameLt;
  /**
   * 中间名 比较(lte)
   */
  private String middleNameLte;
  /**
   * 中间名 比较(contains)
   */
  private String middleNameContains;
  /**
   * 中间名 比较(notcontains)
   */
  private String middleNameNotcontains;
  /**
   * 中间名 比较(startswith)
   */
  private String middleNameStartswith;
  /**
   * 中间名 比较(endswith)
   */
  private String middleNameEndswith;
  /**
   * 中间名 比较(isnull)
   */
  private Boolean middleNameIsnull;
  /**
   * 中间名 比较(isnotnull)
   */
  private Boolean middleNameIsnotnull;

  /**
   * 中间名(精确搜索)
   */
  private List<String> middleNameInList;

  /**
   * 名(模糊搜索)
   */
  private String firstName;

  /**
   * 名 比较(eq)
   */
  private String firstNameEq;
  /**
   * 名 比较(neq)
   */
  private String firstNameNeq;
  /**
   * 名 比较(gt)
   */
  private String firstNameGt;
  /**
   * 名 比较(gte)
   */
  private String firstNameGte;
  /**
   * 名 比较(lt)
   */
  private String firstNameLt;
  /**
   * 名 比较(lte)
   */
  private String firstNameLte;
  /**
   * 名 比较(contains)
   */
  private String firstNameContains;
  /**
   * 名 比较(notcontains)
   */
  private String firstNameNotcontains;
  /**
   * 名 比较(startswith)
   */
  private String firstNameStartswith;
  /**
   * 名 比较(endswith)
   */
  private String firstNameEndswith;
  /**
   * 名 比较(isnull)
   */
  private Boolean firstNameIsnull;
  /**
   * 名 比较(isnotnull)
   */
  private Boolean firstNameIsnotnull;

  /**
   * 名(精确搜索)
   */
  private List<String> firstNameInList;

  /**
   * 国家(模糊搜索)
   */
  private String country;

  /**
   * 国家 比较(eq)
   */
  private String countryEq;
  /**
   * 国家 比较(neq)
   */
  private String countryNeq;
  /**
   * 国家 比较(gt)
   */
  private String countryGt;
  /**
   * 国家 比较(gte)
   */
  private String countryGte;
  /**
   * 国家 比较(lt)
   */
  private String countryLt;
  /**
   * 国家 比较(lte)
   */
  private String countryLte;
  /**
   * 国家 比较(contains)
   */
  private String countryContains;
  /**
   * 国家 比较(notcontains)
   */
  private String countryNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private String countryStartswith;
  /**
   * 国家 比较(endswith)
   */
  private String countryEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean countryIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean countryIsnotnull;

  /**
   * 国家(精确搜索)
   */
  private List<String> countryInList;

  /**
   * 省(模糊搜索)
   */
  private String province;

  /**
   * 省 比较(eq)
   */
  private String provinceEq;
  /**
   * 省 比较(neq)
   */
  private String provinceNeq;
  /**
   * 省 比较(gt)
   */
  private String provinceGt;
  /**
   * 省 比较(gte)
   */
  private String provinceGte;
  /**
   * 省 比较(lt)
   */
  private String provinceLt;
  /**
   * 省 比较(lte)
   */
  private String provinceLte;
  /**
   * 省 比较(contains)
   */
  private String provinceContains;
  /**
   * 省 比较(notcontains)
   */
  private String provinceNotcontains;
  /**
   * 省 比较(startswith)
   */
  private String provinceStartswith;
  /**
   * 省 比较(endswith)
   */
  private String provinceEndswith;
  /**
   * 省 比较(isnull)
   */
  private Boolean provinceIsnull;
  /**
   * 省 比较(isnotnull)
   */
  private Boolean provinceIsnotnull;

  /**
   * 省(精确搜索)
   */
  private List<String> provinceInList;

  /**
   * 市(模糊搜索)
   */
  private String city;

  /**
   * 市 比较(eq)
   */
  private String cityEq;
  /**
   * 市 比较(neq)
   */
  private String cityNeq;
  /**
   * 市 比较(gt)
   */
  private String cityGt;
  /**
   * 市 比较(gte)
   */
  private String cityGte;
  /**
   * 市 比较(lt)
   */
  private String cityLt;
  /**
   * 市 比较(lte)
   */
  private String cityLte;
  /**
   * 市 比较(contains)
   */
  private String cityContains;
  /**
   * 市 比较(notcontains)
   */
  private String cityNotcontains;
  /**
   * 市 比较(startswith)
   */
  private String cityStartswith;
  /**
   * 市 比较(endswith)
   */
  private String cityEndswith;
  /**
   * 市 比较(isnull)
   */
  private Boolean cityIsnull;
  /**
   * 市 比较(isnotnull)
   */
  private Boolean cityIsnotnull;

  /**
   * 市(精确搜索)
   */
  private List<String> cityInList;

  /**
   * 区(模糊搜索)
   */
  private String district;

  /**
   * 区 比较(eq)
   */
  private String districtEq;
  /**
   * 区 比较(neq)
   */
  private String districtNeq;
  /**
   * 区 比较(gt)
   */
  private String districtGt;
  /**
   * 区 比较(gte)
   */
  private String districtGte;
  /**
   * 区 比较(lt)
   */
  private String districtLt;
  /**
   * 区 比较(lte)
   */
  private String districtLte;
  /**
   * 区 比较(contains)
   */
  private String districtContains;
  /**
   * 区 比较(notcontains)
   */
  private String districtNotcontains;
  /**
   * 区 比较(startswith)
   */
  private String districtStartswith;
  /**
   * 区 比较(endswith)
   */
  private String districtEndswith;
  /**
   * 区 比较(isnull)
   */
  private Boolean districtIsnull;
  /**
   * 区 比较(isnotnull)
   */
  private Boolean districtIsnotnull;

  /**
   * 区(精确搜索)
   */
  private List<String> districtInList;

  /**
   * 街道(模糊搜索)
   */
  private String street;

  /**
   * 街道 比较(eq)
   */
  private String streetEq;
  /**
   * 街道 比较(neq)
   */
  private String streetNeq;
  /**
   * 街道 比较(gt)
   */
  private String streetGt;
  /**
   * 街道 比较(gte)
   */
  private String streetGte;
  /**
   * 街道 比较(lt)
   */
  private String streetLt;
  /**
   * 街道 比较(lte)
   */
  private String streetLte;
  /**
   * 街道 比较(contains)
   */
  private String streetContains;
  /**
   * 街道 比较(notcontains)
   */
  private String streetNotcontains;
  /**
   * 街道 比较(startswith)
   */
  private String streetStartswith;
  /**
   * 街道 比较(endswith)
   */
  private String streetEndswith;
  /**
   * 街道 比较(isnull)
   */
  private Boolean streetIsnull;
  /**
   * 街道 比较(isnotnull)
   */
  private Boolean streetIsnotnull;

  /**
   * 街道(精确搜索)
   */
  private List<String> streetInList;

  /**
   * 地址1(模糊搜索)
   */
  private String address;

  /**
   * 地址1 比较(eq)
   */
  private String addressEq;
  /**
   * 地址1 比较(neq)
   */
  private String addressNeq;
  /**
   * 地址1 比较(gt)
   */
  private String addressGt;
  /**
   * 地址1 比较(gte)
   */
  private String addressGte;
  /**
   * 地址1 比较(lt)
   */
  private String addressLt;
  /**
   * 地址1 比较(lte)
   */
  private String addressLte;
  /**
   * 地址1 比较(contains)
   */
  private String addressContains;
  /**
   * 地址1 比较(notcontains)
   */
  private String addressNotcontains;
  /**
   * 地址1 比较(startswith)
   */
  private String addressStartswith;
  /**
   * 地址1 比较(endswith)
   */
  private String addressEndswith;
  /**
   * 地址1 比较(isnull)
   */
  private Boolean addressIsnull;
  /**
   * 地址1 比较(isnotnull)
   */
  private Boolean addressIsnotnull;

  /**
   * 地址1(精确搜索)
   */
  private List<String> addressInList;

  /**
   * 地址2(模糊搜索)
   */
  private String addressExt;

  /**
   * 地址2 比较(eq)
   */
  private String addressExtEq;
  /**
   * 地址2 比较(neq)
   */
  private String addressExtNeq;
  /**
   * 地址2 比较(gt)
   */
  private String addressExtGt;
  /**
   * 地址2 比较(gte)
   */
  private String addressExtGte;
  /**
   * 地址2 比较(lt)
   */
  private String addressExtLt;
  /**
   * 地址2 比较(lte)
   */
  private String addressExtLte;
  /**
   * 地址2 比较(contains)
   */
  private String addressExtContains;
  /**
   * 地址2 比较(notcontains)
   */
  private String addressExtNotcontains;
  /**
   * 地址2 比较(startswith)
   */
  private String addressExtStartswith;
  /**
   * 地址2 比较(endswith)
   */
  private String addressExtEndswith;
  /**
   * 地址2 比较(isnull)
   */
  private Boolean addressExtIsnull;
  /**
   * 地址2 比较(isnotnull)
   */
  private Boolean addressExtIsnotnull;

  /**
   * 地址2(精确搜索)
   */
  private List<String> addressExtInList;

  /**
   * 手机号(模糊搜索)
   */
  private String phone;

  /**
   * 手机号 比较(eq)
   */
  private String phoneEq;
  /**
   * 手机号 比较(neq)
   */
  private String phoneNeq;
  /**
   * 手机号 比较(gt)
   */
  private String phoneGt;
  /**
   * 手机号 比较(gte)
   */
  private String phoneGte;
  /**
   * 手机号 比较(lt)
   */
  private String phoneLt;
  /**
   * 手机号 比较(lte)
   */
  private String phoneLte;
  /**
   * 手机号 比较(contains)
   */
  private String phoneContains;
  /**
   * 手机号 比较(notcontains)
   */
  private String phoneNotcontains;
  /**
   * 手机号 比较(startswith)
   */
  private String phoneStartswith;
  /**
   * 手机号 比较(endswith)
   */
  private String phoneEndswith;
  /**
   * 手机号 比较(isnull)
   */
  private Boolean phoneIsnull;
  /**
   * 手机号 比较(isnotnull)
   */
  private Boolean phoneIsnotnull;

  /**
   * 手机号(精确搜索)
   */
  private List<String> phoneInList;

  /**
   * 邮编(模糊搜索)
   */
  private String postCode;

  /**
   * 邮编 比较(eq)
   */
  private String postCodeEq;
  /**
   * 邮编 比较(neq)
   */
  private String postCodeNeq;
  /**
   * 邮编 比较(gt)
   */
  private String postCodeGt;
  /**
   * 邮编 比较(gte)
   */
  private String postCodeGte;
  /**
   * 邮编 比较(lt)
   */
  private String postCodeLt;
  /**
   * 邮编 比较(lte)
   */
  private String postCodeLte;
  /**
   * 邮编 比较(contains)
   */
  private String postCodeContains;
  /**
   * 邮编 比较(notcontains)
   */
  private String postCodeNotcontains;
  /**
   * 邮编 比较(startswith)
   */
  private String postCodeStartswith;
  /**
   * 邮编 比较(endswith)
   */
  private String postCodeEndswith;
  /**
   * 邮编 比较(isnull)
   */
  private Boolean postCodeIsnull;
  /**
   * 邮编 比较(isnotnull)
   */
  private Boolean postCodeIsnotnull;

  /**
   * 邮编(精确搜索)
   */
  private List<String> postCodeInList;

  /**
   * 税号(模糊搜索)
   */
  private String taxNo;

  /**
   * 税号 比较(eq)
   */
  private String taxNoEq;
  /**
   * 税号 比较(neq)
   */
  private String taxNoNeq;
  /**
   * 税号 比较(gt)
   */
  private String taxNoGt;
  /**
   * 税号 比较(gte)
   */
  private String taxNoGte;
  /**
   * 税号 比较(lt)
   */
  private String taxNoLt;
  /**
   * 税号 比较(lte)
   */
  private String taxNoLte;
  /**
   * 税号 比较(contains)
   */
  private String taxNoContains;
  /**
   * 税号 比较(notcontains)
   */
  private String taxNoNotcontains;
  /**
   * 税号 比较(startswith)
   */
  private String taxNoStartswith;
  /**
   * 税号 比较(endswith)
   */
  private String taxNoEndswith;
  /**
   * 税号 比较(isnull)
   */
  private Boolean taxNoIsnull;
  /**
   * 税号 比较(isnotnull)
   */
  private Boolean taxNoIsnotnull;

  /**
   * 税号(精确搜索)
   */
  private List<String> taxNoInList;

  /**
   * 包裹ID(模糊搜索)
   */
  private String packageIds;

  /**
   * 包裹ID 比较(eq)
   */
  private String packageIdsEq;
  /**
   * 包裹ID 比较(neq)
   */
  private String packageIdsNeq;
  /**
   * 包裹ID 比较(gt)
   */
  private String packageIdsGt;
  /**
   * 包裹ID 比较(gte)
   */
  private String packageIdsGte;
  /**
   * 包裹ID 比较(lt)
   */
  private String packageIdsLt;
  /**
   * 包裹ID 比较(lte)
   */
  private String packageIdsLte;
  /**
   * 包裹ID 比较(contains)
   */
  private String packageIdsContains;
  /**
   * 包裹ID 比较(notcontains)
   */
  private String packageIdsNotcontains;
  /**
   * 包裹ID 比较(startswith)
   */
  private String packageIdsStartswith;
  /**
   * 包裹ID 比较(endswith)
   */
  private String packageIdsEndswith;
  /**
   * 包裹ID 比较(isnull)
   */
  private Boolean packageIdsIsnull;
  /**
   * 包裹ID 比较(isnotnull)
   */
  private Boolean packageIdsIsnotnull;

  /**
   * 包裹ID(精确搜索)
   */
  private List<String> packageIdsInList;

  /**
   * 包裹运单信息(模糊搜索)
   */
  private String packageWaybillList;

  /**
   * 包裹运单信息 比较(eq)
   */
  private String packageWaybillListEq;
  /**
   * 包裹运单信息 比较(neq)
   */
  private String packageWaybillListNeq;
  /**
   * 包裹运单信息 比较(gt)
   */
  private String packageWaybillListGt;
  /**
   * 包裹运单信息 比较(gte)
   */
  private String packageWaybillListGte;
  /**
   * 包裹运单信息 比较(lt)
   */
  private String packageWaybillListLt;
  /**
   * 包裹运单信息 比较(lte)
   */
  private String packageWaybillListLte;
  /**
   * 包裹运单信息 比较(contains)
   */
  private String packageWaybillListContains;
  /**
   * 包裹运单信息 比较(notcontains)
   */
  private String packageWaybillListNotcontains;
  /**
   * 包裹运单信息 比较(startswith)
   */
  private String packageWaybillListStartswith;
  /**
   * 包裹运单信息 比较(endswith)
   */
  private String packageWaybillListEndswith;
  /**
   * 包裹运单信息 比较(isnull)
   */
  private Boolean packageWaybillListIsnull;
  /**
   * 包裹运单信息 比较(isnotnull)
   */
  private Boolean packageWaybillListIsnotnull;

  /**
   * 包裹运单信息(精确搜索)
   */
  private List<String> packageWaybillListInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
